home *** CD-ROM | disk | FTP | other *** search
/ PC World 2007 March / PCWorld_2007-03_cd.bin / domacnost a kancelar / scribus / scribus-1.3.3.7-win32-install.exe / lib / zipfile.py < prev   
Encoding:
Text File  |  2005-02-18  |  26.2 KB  |  616 lines
  1. "Read and write ZIP files."
  2.  
  3. import struct, os, time
  4. import binascii
  5.  
  6. try:
  7.     import zlib # We may need its compression method
  8. except ImportError:
  9.     zlib = None
  10.  
  11. __all__ = ["BadZipfile", "error", "ZIP_STORED", "ZIP_DEFLATED", "is_zipfile",
  12.            "ZipInfo", "ZipFile", "PyZipFile"]
  13.  
  14. class BadZipfile(Exception):
  15.     pass
  16. error = BadZipfile      # The exception raised by this module
  17.  
  18. # constants for Zip file compression methods
  19. ZIP_STORED = 0
  20. ZIP_DEFLATED = 8
  21. # Other ZIP compression methods not supported
  22.  
  23. # Here are some struct module formats for reading headers
  24. structEndArchive = "<4s4H2lH"     # 9 items, end of archive, 22 bytes
  25. stringEndArchive = "PK\005\006"   # magic number for end of archive record
  26. structCentralDir = "<4s4B4HlLL5HLl"# 19 items, central directory, 46 bytes
  27. stringCentralDir = "PK\001\002"   # magic number for central directory
  28. structFileHeader = "<4s2B4HlLL2H"  # 12 items, file header record, 30 bytes
  29. stringFileHeader = "PK\003\004"   # magic number for file header
  30.  
  31. # indexes of entries in the central directory structure
  32. _CD_SIGNATURE = 0
  33. _CD_CREATE_VERSION = 1
  34. _CD_CREATE_SYSTEM = 2
  35. _CD_EXTRACT_VERSION = 3
  36. _CD_EXTRACT_SYSTEM = 4                  # is this meaningful?
  37. _CD_FLAG_BITS = 5
  38. _CD_COMPRESS_TYPE = 6
  39. _CD_TIME = 7
  40. _CD_DATE = 8
  41. _CD_CRC = 9
  42. _CD_COMPRESSED_SIZE = 10
  43. _CD_UNCOMPRESSED_SIZE = 11
  44. _CD_FILENAME_LENGTH = 12
  45. _CD_EXTRA_FIELD_LENGTH = 13
  46. _CD_COMMENT_LENGTH = 14
  47. _CD_DISK_NUMBER_START = 15
  48. _CD_INTERNAL_FILE_ATTRIBUTES = 16
  49. _CD_EXTERNAL_FILE_ATTRIBUTES = 17
  50. _CD_LOCAL_HEADER_OFFSET = 18
  51.  
  52. # indexes of entries in the local file header structure
  53. _FH_SIGNATURE = 0
  54. _FH_EXTRACT_VERSION = 1
  55. _FH_EXTRACT_SYSTEM = 2                  # is this meaningful?
  56. _FH_GENERAL_PURPOSE_FLAG_BITS = 3
  57. _FH_COMPRESSION_METHOD = 4
  58. _FH_LAST_MOD_TIME = 5
  59. _FH_LAST_MOD_DATE = 6
  60. _FH_CRC = 7
  61. _FH_COMPRESSED_SIZE = 8
  62. _FH_UNCOMPRESSED_SIZE = 9
  63. _FH_FILENAME_LENGTH = 10
  64. _FH_EXTRA_FIELD_LENGTH = 11
  65.  
  66. def is_zipfile(filename):
  67.     """Quickly see if file is a ZIP file by checking the magic number."""
  68.     try:
  69.         fpin = open(filename, "rb")
  70.         endrec = _EndRecData(fpin)
  71.         fpin.close()
  72.         if endrec:
  73.             return True                 # file has correct magic number
  74.     except IOError:
  75.         pass
  76.     return False
  77.  
  78. def _EndRecData(fpin):
  79.     """Return data from the "End of Central Directory" record, or None.
  80.  
  81.     The data is a list of the nine items in the ZIP "End of central dir"
  82.     record followed by a tenth item, the file seek offset of this record."""
  83.     fpin.seek(-22, 2)               # Assume no archive comment.
  84.     filesize = fpin.tell() + 22     # Get file size
  85.     data = fpin.read()
  86.     if data[0:4] == stringEndArchive and data[-2:] == "\000\000":
  87.         endrec = struct.unpack(structEndArchive, data)
  88.         endrec = list(endrec)
  89.         endrec.append("")               # Append the archive comment
  90.         endrec.append(filesize - 22)    # Append the record start offset
  91.         return endrec
  92.     # Search the last END_BLOCK bytes of the file for the record signature.
  93.     # The comment is appended to the ZIP file and has a 16 bit length.
  94.     # So the comment may be up to 64K long.  We limit the search for the
  95.     # signature to a few Kbytes at the end of the file for efficiency.
  96.     # also, the signature must not appear in the comment.
  97.     END_BLOCK = min(filesize, 1024 * 4)
  98.     fpin.seek(filesize - END_BLOCK, 0)
  99.     data = fpin.read()
  100.     start = data.rfind(stringEndArchive)
  101.     if start >= 0:     # Correct signature string was found
  102.         endrec = struct.unpack(structEndArchive, data[start:start+22])
  103.         endrec = list(endrec)
  104.         comment = data[start+22:]
  105.         if endrec[7] == len(comment):     # Comment length checks out
  106.             # Append the archive comment and start offset
  107.             endrec.append(comment)
  108.             endrec.append(filesize - END_BLOCK + start)
  109.             return endrec
  110.     return      # Error, return None
  111.  
  112.  
  113. class ZipInfo:
  114.     """Class with attributes describing each file in the ZIP archive."""
  115.  
  116.     def __init__(self, filename="NoName", date_time=(1980,1,1,0,0,0)):
  117.         self.orig_filename = filename   # Original file name in archive
  118. # Terminate the file name at the first null byte.  Null bytes in file
  119. # names are used as tricks by viruses in archives.
  120.         null_byte = filename.find(chr(0))
  121.         if null_byte >= 0:
  122.             filename = filename[0:null_byte]
  123. # This is used to ensure paths in generated ZIP files always use
  124. # forward slashes as the directory separator, as required by the
  125. # ZIP format specification.
  126.         if os.sep != "/":
  127.             filename = filename.replace(os.sep, "/")
  128.         self.filename = filename        # Normalized file name
  129.         self.date_time = date_time      # year, month, day, hour, min, sec
  130.         # Standard values:
  131.         self.compress_type = ZIP_STORED # Type of compression for the file
  132.         self.comment = ""               # Comment for each file
  133.         self.extra = ""                 # ZIP extra data
  134.         self.create_system = 0          # System which created ZIP archive
  135.         self.create_version = 20        # Version which created ZIP archive
  136.         self.extract_version = 20       # Version needed to extract archive
  137.         self.reserved = 0               # Must be zero
  138.         self.flag_bits = 0              # ZIP flag bits
  139.         self.volume = 0                 # Volume number of file header
  140.         self.internal_attr = 0          # Internal attributes
  141.         self.external_attr = 0          # External file attributes
  142.         # Other attributes are set by class ZipFile:
  143.         # header_offset         Byte offset to the file header
  144.         # file_offset           Byte offset to the start of the file data
  145.         # CRC                   CRC-32 of the uncompressed file
  146.         # compress_size         Size of the compressed file
  147.         # file_size             Size of the uncompressed file
  148.  
  149.     def FileHeader(self):
  150.         """Return the per-file header as a string."""
  151.         dt = self.date_time
  152.         dosdate = (dt[0] - 1980) << 9 | dt[1] << 5 | dt[2]
  153.         dostime = dt[3] << 11 | dt[4] << 5 | (dt[5] // 2)
  154.         if self.flag_bits & 0x08:
  155.             # Set these to zero because we write them after the file data
  156.             CRC = compress_size = file_size = 0
  157.         else:
  158.             CRC = self.CRC
  159.             compress_size = self.compress_size
  160.             file_size = self.file_size
  161.         header = struct.pack(structFileHeader, stringFileHeader,
  162.                  self.extract_version, self.reserved, self.flag_bits,
  163.                  self.compress_type, dostime, dosdate, CRC,
  164.                  compress_size, file_size,
  165.                  len(self.filename), len(self.extra))
  166.         return header + self.filename + self.extra
  167.  
  168.  
  169. class ZipFile:
  170.     """ Class with methods to open, read, write, close, list zip files.
  171.  
  172.     z = ZipFile(file, mode="r", compression=ZIP_STORED)
  173.  
  174.     file: Either the path to the file, or a file-like object.
  175.           If it is a path, the file will be opened and closed by ZipFile.
  176.     mode: The mode can be either read "r", write "w" or append "a".
  177.     compression: ZIP_STORED (no compression) or ZIP_DEFLATED (requires zlib).
  178.     """
  179.  
  180.     fp = None                   # Set here since __del__ checks it
  181.  
  182.     def __init__(self, file, mode="r", compression=ZIP_STORED):
  183.         """Open the ZIP file with mode read "r", write "w" or append "a"."""
  184.         if compression == ZIP_STORED:
  185.             pass
  186.         elif compression == ZIP_DEFLATED:
  187.             if not zlib:
  188.                 raise RuntimeError,\
  189.                       "Compression requires the (missing) zlib module"
  190.         else:
  191.             raise RuntimeError, "That compression method is not supported"
  192.         self.debug = 0  # Level of printing: 0 through 3
  193.         self.NameToInfo = {}    # Find file info given name
  194.         self.filelist = []      # List of ZipInfo instances for archive
  195.         self.compression = compression  # Method of compression
  196.         self.mode = key = mode.replace('b', '')[0]
  197.  
  198.         # Check if we were passed a file-like object
  199.         if isinstance(file, basestring):
  200.             self._filePassed = 0
  201.             self.filename = file
  202.             modeDict = {'r' : 'rb', 'w': 'wb', 'a' : 'r+b'}
  203.             self.fp = open(file, modeDict[mode])
  204.         else:
  205.             self._filePassed = 1
  206.             self.fp = file
  207.             self.filename = getattr(file, 'name', None)
  208.  
  209.         if key == 'r':
  210.             self._GetContents()
  211.         elif key == 'w':
  212.             pass
  213.         elif key == 'a':
  214.             try:                        # See if file is a zip file
  215.                 self._RealGetContents()
  216.                 # seek to start of directory and overwrite
  217.                 self.fp.seek(self.start_dir, 0)
  218.             except BadZipfile:          # file is not a zip file, just append
  219.                 self.fp.seek(0, 2)
  220.         else:
  221.             if not self._filePassed:
  222.                 self.fp.close()
  223.                 self.fp = None
  224.             raise RuntimeError, 'Mode must be "r", "w" or "a"'
  225.  
  226.     def _GetContents(self):
  227.         """Read the directory, making sure we close the file if the format
  228.         is bad."""
  229.         try:
  230.             self._RealGetContents()
  231.         except BadZipfile:
  232.             if not self._filePassed:
  233.                 self.fp.close()
  234.                 self.fp = None
  235.             raise
  236.  
  237.     def _RealGetContents(self):
  238.         """Read in the table of contents for the ZIP file."""
  239.         fp = self.fp
  240.         endrec = _EndRecData(fp)
  241.         if not endrec:
  242.             raise BadZipfile, "File is not a zip file"
  243.         if self.debug > 1:
  244.             print endrec
  245.         size_cd = endrec[5]             # bytes in central directory
  246.         offset_cd = endrec[6]   # offset of central directory
  247.         self.comment = endrec[8]        # archive comment
  248.         # endrec[9] is the offset of the "End of Central Dir" record
  249.         x = endrec[9] - size_cd
  250.         # "concat" is zero, unless zip was concatenated to another file
  251.         concat = x - offset_cd
  252.         if self.debug > 2:
  253.             print "given, inferred, offset", offset_cd, x, concat
  254.         # self.start_dir:  Position of start of central directory
  255.         self.start_dir = offset_cd + concat
  256.         fp.seek(self.start_dir, 0)
  257.         total = 0
  258.         while total < size_cd:
  259.             centdir = fp.read(46)
  260.             total = total + 46
  261.             if centdir[0:4] != stringCentralDir:
  262.                 raise BadZipfile, "Bad magic number for central directory"
  263.             centdir = struct.unpack(structCentralDir, centdir)
  264.             if self.debug > 2:
  265.                 print centdir
  266.             filename = fp.read(centdir[_CD_FILENAME_LENGTH])
  267.             # Create ZipInfo instance to store file information
  268.             x = ZipInfo(filename)
  269.             x.extra = fp.read(centdir[_CD_EXTRA_FIELD_LENGTH])
  270.             x.comment = fp.read(centdir[_CD_COMMENT_LENGTH])
  271.             total = (total + centdir[_CD_FILENAME_LENGTH]
  272.                      + centdir[_CD_EXTRA_FIELD_LENGTH]
  273.                      + centdir[_CD_COMMENT_LENGTH])
  274.             x.header_offset = centdir[_CD_LOCAL_HEADER_OFFSET] + concat
  275.             # file_offset must be computed below...
  276.             (x.create_version, x.create_system, x.extract_version, x.reserved,
  277.                 x.flag_bits, x.compress_type, t, d,
  278.                 x.CRC, x.compress_size, x.file_size) = centdir[1:12]
  279.             x.volume, x.internal_attr, x.external_attr = centdir[15:18]
  280.             # Convert date/time code to (year, month, day, hour, min, sec)
  281.             x.date_time = ( (d>>9)+1980, (d>>5)&0xF, d&0x1F,
  282.                                      t>>11, (t>>5)&0x3F, (t&0x1F) * 2 )
  283.             self.filelist.append(x)
  284.             self.NameToInfo[x.filename] = x
  285.             if self.debug > 2:
  286.                 print "total", total
  287.         for data in self.filelist:
  288.             fp.seek(data.header_offset, 0)
  289.             fheader = fp.read(30)
  290.             if fheader[0:4] != stringFileHeader:
  291.                 raise BadZipfile, "Bad magic number for file header"
  292.             fheader = struct.unpack(structFileHeader, fheader)
  293.             # file_offset is computed here, since the extra field for
  294.             # the central directory and for the local file header
  295.             # refer to different fields, and they can have different
  296.             # lengths
  297.             data.file_offset = (data.header_offset + 30
  298.                                 + fheader[_FH_FILENAME_LENGTH]
  299.                                 + fheader[_FH_EXTRA_FIELD_LENGTH])
  300.             fname = fp.read(fheader[_FH_FILENAME_LENGTH])
  301.             if fname != data.orig_filename:
  302.                 raise RuntimeError, \
  303.                       'File name in directory "%s" and header "%s" differ.' % (
  304.                           data.orig_filename, fname)
  305.  
  306.     def namelist(self):
  307.         """Return a list of file names in the archive."""
  308.         l = []
  309.         for data in self.filelist:
  310.             l.append(data.filename)
  311.         return l
  312.  
  313.     def infolist(self):
  314.         """Return a list of class ZipInfo instances for files in the
  315.         archive."""
  316.         return self.filelist
  317.  
  318.     def printdir(self):
  319.         """Print a table of contents for the zip file."""
  320.         print "%-46s %19s %12s" % ("File Name", "Modified    ", "Size")
  321.         for zinfo in self.filelist:
  322.             date = "%d-%02d-%02d %02d:%02d:%02d" % zinfo.date_time
  323.             print "%-46s %s %12d" % (zinfo.filename, date, zinfo.file_size)
  324.  
  325.     def testzip(self):
  326.         """Read all the files and check the CRC."""
  327.         for zinfo in self.filelist:
  328.             try:
  329.                 self.read(zinfo.filename)       # Check CRC-32
  330.             except BadZipfile:
  331.                 return zinfo.filename
  332.  
  333.     def getinfo(self, name):
  334.         """Return the instance of ZipInfo given 'name'."""
  335.         return self.NameToInfo[name]
  336.  
  337.     def read(self, name):
  338.         """Return file bytes (as a string) for name."""
  339.         if self.mode not in ("r", "a"):
  340.             raise RuntimeError, 'read() requires mode "r" or "a"'
  341.         if not self.fp:
  342.             raise RuntimeError, \
  343.                   "Attempt to read ZIP archive that was already closed"
  344.         zinfo = self.getinfo(name)
  345.         filepos = self.fp.tell()
  346.         self.fp.seek(zinfo.file_offset, 0)
  347.         bytes = self.fp.read(zinfo.compress_size)
  348.         self.fp.seek(filepos, 0)
  349.         if zinfo.compress_type == ZIP_STORED:
  350.             pass
  351.         elif zinfo.compress_type == ZIP_DEFLATED:
  352.             if not zlib:
  353.                 raise RuntimeError, \
  354.                       "De-compression requires the (missing) zlib module"
  355.             # zlib compress/decompress code by Jeremy Hylton of CNRI
  356.             dc = zlib.decompressobj(-15)
  357.             bytes = dc.decompress(bytes)
  358.             # need to feed in unused pad byte so that zlib won't choke
  359.             ex = dc.decompress('Z') + dc.flush()
  360.             if ex:
  361.                 bytes = bytes + ex
  362.         else:
  363.             raise BadZipfile, \
  364.                   "Unsupported compression method %d for file %s" % \
  365.             (zinfo.compress_type, name)
  366.         crc = binascii.crc32(bytes)
  367.         if crc != zinfo.CRC:
  368.             raise BadZipfile, "Bad CRC-32 for file %s" % name
  369.         return bytes
  370.  
  371.     def _writecheck(self, zinfo):
  372.         """Check for errors before writing a file to the archive."""
  373.         if zinfo.filename in self.NameToInfo:
  374.             if self.debug:      # Warning for duplicate names
  375.                 print "Duplicate name:", zinfo.filename
  376.         if self.mode not in ("w", "a"):
  377.             raise RuntimeError, 'write() requires mode "w" or "a"'
  378.         if not self.fp:
  379.             raise RuntimeError, \
  380.                   "Attempt to write ZIP archive that was already closed"
  381.         if zinfo.compress_type == ZIP_DEFLATED and not zlib:
  382.             raise RuntimeError, \
  383.                   "Compression requires the (missing) zlib module"
  384.         if zinfo.compress_type not in (ZIP_STORED, ZIP_DEFLATED):
  385.             raise RuntimeError, \
  386.                   "That compression method is not supported"
  387.  
  388.     def write(self, filename, arcname=None, compress_type=None):
  389.         """Put the bytes from filename into the archive under the name
  390.         arcname."""
  391.         st = os.stat(filename)
  392.         mtime = time.localtime(st.st_mtime)
  393.         date_time = mtime[0:6]
  394.         # Create ZipInfo instance to store file information
  395.         if arcname is None:
  396.             zinfo = ZipInfo(filename, date_time)
  397.         else:
  398.             zinfo = ZipInfo(arcname, date_time)
  399.         zinfo.external_attr = (st[0] & 0xFFFF) << 16L      # Unix attributes
  400.         if compress_type is None:
  401.             zinfo.compress_type = self.compression
  402.         else:
  403.             zinfo.compress_type = compress_type
  404.         self._writecheck(zinfo)
  405.         fp = open(filename, "rb")
  406.         zinfo.flag_bits = 0x00
  407.         zinfo.header_offset = self.fp.tell()    # Start of header bytes
  408.         # Must overwrite CRC and sizes with correct data later
  409.         zinfo.CRC = CRC = 0
  410.         zinfo.compress_size = compress_size = 0
  411.         zinfo.file_size = file_size = 0
  412.         self.fp.write(zinfo.FileHeader())
  413.         zinfo.file_offset = self.fp.tell()      # Start of file bytes
  414.         if zinfo.compress_type == ZIP_DEFLATED:
  415.             cmpr = zlib.compressobj(zlib.Z_DEFAULT_COMPRESSION,
  416.                  zlib.DEFLATED, -15)
  417.         else:
  418.             cmpr = None
  419.         while 1:
  420.             buf = fp.read(1024 * 8)
  421.             if not buf:
  422.                 break
  423.             file_size = file_size + len(buf)
  424.             CRC = binascii.crc32(buf, CRC)
  425.             if cmpr:
  426.                 buf = cmpr.compress(buf)
  427.                 compress_size = compress_size + len(buf)
  428.             self.fp.write(buf)
  429.         fp.close()
  430.         if cmpr:
  431.             buf = cmpr.flush()
  432.             compress_size = compress_size + len(buf)
  433.             self.fp.write(buf)
  434.             zinfo.compress_size = compress_size
  435.         else:
  436.             zinfo.compress_size = file_size
  437.         zinfo.CRC = CRC
  438.         zinfo.file_size = file_size
  439.         # Seek backwards and write CRC and file sizes
  440.         position = self.fp.tell()       # Preserve current position in file
  441.         self.fp.seek(zinfo.header_offset + 14, 0)
  442.         self.fp.write(struct.pack("<lLL", zinfo.CRC, zinfo.compress_size,
  443.               zinfo.file_size))
  444.         self.fp.seek(position, 0)
  445.         self.filelist.append(zinfo)
  446.         self.NameToInfo[zinfo.filename] = zinfo
  447.  
  448.     def writestr(self, zinfo_or_arcname, bytes):
  449.         """Write a file into the archive.  The contents is the string
  450.         'bytes'.  'zinfo_or_arcname' is either a ZipInfo instance or
  451.         the name of the file in the archive."""
  452.         if not isinstance(zinfo_or_arcname, ZipInfo):
  453.             zinfo = ZipInfo(filename=zinfo_or_arcname,
  454.                             date_time=time.localtime(time.time()))
  455.             zinfo.compress_type = self.compression
  456.         else:
  457.             zinfo = zinfo_or_arcname
  458.         self._writecheck(zinfo)
  459.         zinfo.file_size = len(bytes)            # Uncompressed size
  460.         zinfo.CRC = binascii.crc32(bytes)       # CRC-32 checksum
  461.         if zinfo.compress_type == ZIP_DEFLATED:
  462.             co = zlib.compressobj(zlib.Z_DEFAULT_COMPRESSION,
  463.                  zlib.DEFLATED, -15)
  464.             bytes = co.compress(bytes) + co.flush()
  465.             zinfo.compress_size = len(bytes)    # Compressed size
  466.         else:
  467.             zinfo.compress_size = zinfo.file_size
  468.         zinfo.header_offset = self.fp.tell()    # Start of header bytes
  469.         self.fp.write(zinfo.FileHeader())
  470.         zinfo.file_offset = self.fp.tell()      # Start of file bytes
  471.         self.fp.write(bytes)
  472.         if zinfo.flag_bits & 0x08:
  473.             # Write CRC and file sizes after the file data
  474.             self.fp.write(struct.pack("<lLL", zinfo.CRC, zinfo.compress_size,
  475.                   zinfo.file_size))
  476.         self.filelist.append(zinfo)
  477.         self.NameToInfo[zinfo.filename] = zinfo
  478.  
  479.     def __del__(self):
  480.         """Call the "close()" method in case the user forgot."""
  481.         self.close()
  482.  
  483.     def close(self):
  484.         """Close the file, and for mode "w" and "a" write the ending
  485.         records."""
  486.         if self.fp is None:
  487.             return
  488.         if self.mode in ("w", "a"):             # write ending records
  489.             count = 0
  490.             pos1 = self.fp.tell()
  491.             for zinfo in self.filelist:         # write central directory
  492.                 count = count + 1
  493.                 dt = zinfo.date_time
  494.                 dosdate = (dt[0] - 1980) << 9 | dt[1] << 5 | dt[2]
  495.                 dostime = dt[3] << 11 | dt[4] << 5 | (dt[5] // 2)
  496.                 centdir = struct.pack(structCentralDir,
  497.                   stringCentralDir, zinfo.create_version,
  498.                   zinfo.create_system, zinfo.extract_version, zinfo.reserved,
  499.                   zinfo.flag_bits, zinfo.compress_type, dostime, dosdate,
  500.                   zinfo.CRC, zinfo.compress_size, zinfo.file_size,
  501.                   len(zinfo.filename), len(zinfo.extra), len(zinfo.comment),
  502.                   0, zinfo.internal_attr, zinfo.external_attr,
  503.                   zinfo.header_offset)
  504.                 self.fp.write(centdir)
  505.                 self.fp.write(zinfo.filename)
  506.                 self.fp.write(zinfo.extra)
  507.                 self.fp.write(zinfo.comment)
  508.             pos2 = self.fp.tell()
  509.             # Write end-of-zip-archive record
  510.             endrec = struct.pack(structEndArchive, stringEndArchive,
  511.                      0, 0, count, count, pos2 - pos1, pos1, 0)
  512.             self.fp.write(endrec)
  513.             self.fp.flush()
  514.         if not self._filePassed:
  515.             self.fp.close()
  516.         self.fp = None
  517.  
  518.  
  519. class PyZipFile(ZipFile):
  520.     """Class to create ZIP archives with Python library files and packages."""
  521.  
  522.     def writepy(self, pathname, basename = ""):
  523.         """Add all files from "pathname" to the ZIP archive.
  524.  
  525.         If pathname is a package directory, search the directory and
  526.         all package subdirectories recursively for all *.py and enter
  527.         the modules into the archive.  If pathname is a plain
  528.         directory, listdir *.py and enter all modules.  Else, pathname
  529.         must be a Python *.py file and the module will be put into the
  530.         archive.  Added modules are always module.pyo or module.pyc.
  531.         This method will compile the module.py into module.pyc if
  532.         necessary.
  533.         """
  534.         dir, name = os.path.split(pathname)
  535.         if os.path.isdir(pathname):
  536.             initname = os.path.join(pathname, "__init__.py")
  537.             if os.path.isfile(initname):
  538.                 # This is a package directory, add it
  539.                 if basename:
  540.                     basename = "%s/%s" % (basename, name)
  541.                 else:
  542.                     basename = name
  543.                 if self.debug:
  544.                     print "Adding package in", pathname, "as", basename
  545.                 fname, arcname = self._get_codename(initname[0:-3], basename)
  546.                 if self.debug:
  547.                     print "Adding", arcname
  548.                 self.write(fname, arcname)
  549.                 dirlist = os.listdir(pathname)
  550.                 dirlist.remove("__init__.py")
  551.                 # Add all *.py files and package subdirectories
  552.                 for filename in dirlist:
  553.                     path = os.path.join(pathname, filename)
  554.                     root, ext = os.path.splitext(filename)
  555.                     if os.path.isdir(path):
  556.                         if os.path.isfile(os.path.join(path, "__init__.py")):
  557.                             # This is a package directory, add it
  558.                             self.writepy(path, basename)  # Recursive call
  559.                     elif ext == ".py":
  560.                         fname, arcname = self._get_codename(path[0:-3],
  561.                                          basename)
  562.                         if self.debug:
  563.                             print "Adding", arcname
  564.                         self.write(fname, arcname)
  565.             else:
  566.                 # This is NOT a package directory, add its files at top level
  567.                 if self.debug:
  568.                     print "Adding files from directory", pathname
  569.                 for filename in os.listdir(pathname):
  570.                     path = os.path.join(pathname, filename)
  571.                     root, ext = os.path.splitext(filename)
  572.                     if ext == ".py":
  573.                         fname, arcname = self._get_codename(path[0:-3],
  574.                                          basename)
  575.                         if self.debug:
  576.                             print "Adding", arcname
  577.                         self.write(fname, arcname)
  578.         else:
  579.             if pathname[-3:] != ".py":
  580.                 raise RuntimeError, \
  581.                       'Files added with writepy() must end with ".py"'
  582.             fname, arcname = self._get_codename(pathname[0:-3], basename)
  583.             if self.debug:
  584.                 print "Adding file", arcname
  585.             self.write(fname, arcname)
  586.  
  587.     def _get_codename(self, pathname, basename):
  588.         """Return (filename, archivename) for the path.
  589.  
  590.         Given a module name path, return the correct file path and
  591.         archive name, compiling if necessary.  For example, given
  592.         /python/lib/string, return (/python/lib/string.pyc, string).
  593.         """
  594.         file_py  = pathname + ".py"
  595.         file_pyc = pathname + ".pyc"
  596.         file_pyo = pathname + ".pyo"
  597.         if os.path.isfile(file_pyo) and \
  598.                             os.stat(file_pyo).st_mtime >= os.stat(file_py).st_mtime:
  599.             fname = file_pyo    # Use .pyo file
  600.         elif not os.path.isfile(file_pyc) or \
  601.              os.stat(file_pyc).st_mtime < os.stat(file_py).st_mtime:
  602.             import py_compile
  603.             if self.debug:
  604.                 print "Compiling", file_py
  605.             try:
  606.                 py_compile.compile(file_py, file_pyc, None, True)
  607.             except py_compile.PyCompileError,err:
  608.                 print err.msg
  609.             fname = file_pyc
  610.         else:
  611.             fname = file_pyc
  612.         archivename = os.path.split(fname)[1]
  613.         if basename:
  614.             archivename = "%s/%s" % (basename, archivename)
  615.         return (fname, archivename)
  616.